<?php
    // $Id: tag_test.php 424 2006-07-21 02:20:17Z will $
    
    require_once(dirname(__FILE__) . '/../tag.php');
    require_once(dirname(__FILE__) . '/../encoding.php');
    
    Mock::generate('SimpleMultipartEncoding');
    
    class TestOfTag extends UnitTestCase {
        
        function testStartValuesWithoutAdditionalContent() {
            $tag = new SimpleTitleTag(array('a' => '1', 'b' => ''));
            $this->assertEqual($tag->getTagName(), 'title');
            $this->assertIdentical($tag->getAttribute('a'), '1');
            $this->assertIdentical($tag->getAttribute('b'), '');
            $this->assertIdentical($tag->getAttribute('c'), false);
            $this->assertIdentical($tag->getContent(), '');
        }
        
        function testTitleContent() {
            $tag = &new SimpleTitleTag(array());
            $this->assertTrue($tag->expectEndTag());
            $tag->addContent('Hello');
            $tag->addContent('World');
            $this->assertEqual($tag->getText(), 'HelloWorld');
        }
        
        function testMessyTitleContent() {
            $tag = &new SimpleTitleTag(array());
            $this->assertTrue($tag->expectEndTag());
            $tag->addContent('<b>Hello</b>');
            $tag->addContent('<em>World</em>');
            $this->assertEqual($tag->getText(), 'HelloWorld');
        }
        
        function testTagWithNoEnd() {
            $tag = &new SimpleTextTag(array());
            $this->assertFalse($tag->expectEndTag());
        }
        
        function testAnchorHref() {
            $tag = &new SimpleAnchorTag(array('href' => 'http://here/'));
            $this->assertEqual($tag->getHref(), 'http://here/');
            
            $tag = &new SimpleAnchorTag(array('href' => ''));
            $this->assertIdentical($tag->getAttribute('href'), '');
            $this->assertIdentical($tag->getHref(), '');
            
            $tag = &new SimpleAnchorTag(array());
            $this->assertIdentical($tag->getAttribute('href'), false);
            $this->assertIdentical($tag->getHref(), '');
        }
        
        function testIsIdMatchesIdAttribute() {
            $tag = &new SimpleAnchorTag(array('href' => 'http://here/', 'id' => 7));
            $this->assertIdentical($tag->getAttribute('id'), '7');
            $this->assertTrue($tag->isId(7));
        }
    }
    
    class TestOfWidget extends UnitTestCase {
        
        function testTextEmptyDefault() {
            $tag = &new SimpleTextTag(array('type' => 'text'));
            $this->assertIdentical($tag->getDefault(), '');
            $this->assertIdentical($tag->getValue(), '');
        }
        
        function testSettingOfExternalLabel() {
            $tag = &new SimpleTextTag(array('type' => 'text'));
            $tag->setLabel('it');
            $this->assertTrue($tag->isLabel('it'));
        }
        
        function testTextDefault() {
            $tag = &new SimpleTextTag(array('value' => 'aaa'));
            $this->assertEqual($tag->getDefault(), 'aaa');
            $this->assertEqual($tag->getValue(), 'aaa');
        }
        
        function testSettingTextValue() {
            $tag = &new SimpleTextTag(array('value' => 'aaa'));
            $tag->setValue('bbb');
            $this->assertEqual($tag->getValue(), 'bbb');
            $tag->resetValue();
            $this->assertEqual($tag->getValue(), 'aaa');
        }
        
        function testFailToSetHiddenValue() {
            $tag = &new SimpleTextTag(array('value' => 'aaa', 'type' => 'hidden'));
            $this->assertFalse($tag->setValue('bbb'));
            $this->assertEqual($tag->getValue(), 'aaa');
        }
        
        function testSubmitDefaults() {
            $tag = &new SimpleSubmitTag(array('type' => 'submit'));
            $this->assertIdentical($tag->getName(), false);
            $this->assertEqual($tag->getValue(), 'Submit');
            $this->assertFalse($tag->setValue('Cannot set this'));
            $this->assertEqual($tag->getValue(), 'Submit');
            $this->assertEqual($tag->getLabel(), 'Submit');
            
            $encoding = &new MockSimpleMultipartEncoding();
            $encoding->expectNever('add');
            $tag->write($encoding);
        }
        
        function testPopulatedSubmit() {
            $tag = &new SimpleSubmitTag(
                    array('type' => 'submit', 'name' => 's', 'value' => 'Ok!'));
            $this->assertEqual($tag->getName(), 's');
            $this->assertEqual($tag->getValue(), 'Ok!');
            $this->assertEqual($tag->getLabel(), 'Ok!');
            
            $encoding = &new MockSimpleMultipartEncoding();
            $encoding->expectOnce('add', array('s', 'Ok!'));
            $tag->write($encoding);
        }
        
        function testImageSubmit() {
            $tag = &new SimpleImageSubmitTag(
                    array('type' => 'image', 'name' => 's', 'alt' => 'Label'));
            $this->assertEqual($tag->getName(), 's');
            $this->assertEqual($tag->getLabel(), 'Label');
            
            $encoding = &new MockSimpleMultipartEncoding();
            $encoding->expectAt(0, 'add', array('s.x', 20));
            $encoding->expectAt(1, 'add', array('s.y', 30));
            $tag->write($encoding, 20, 30);
        }
        
        function testImageSubmitTitlePreferredOverAltForLabel() {
            $tag = &new SimpleImageSubmitTag(
                    array('type' => 'image', 'name' => 's', 'alt' => 'Label', 'title' => 'Title'));
            $this->assertEqual($tag->getLabel(), 'Title');
        }
        
        function testButton() {
            $tag = &new SimpleButtonTag(
                    array('type' => 'submit', 'name' => 's', 'value' => 'do'));
            $tag->addContent('I am a button');
            $this->assertEqual($tag->getName(), 's');
            $this->assertEqual($tag->getValue(), 'do');
            $this->assertEqual($tag->getLabel(), 'I am a button');

            $encoding = &new MockSimpleMultipartEncoding();
            $encoding->expectOnce('add', array('s', 'do'));
            $tag->write($encoding);
        }
    }
    
    class TestOfTextArea extends UnitTestCase {
        
        function testDefault() {
            $tag = &new SimpleTextAreaTag(array('name' => 'a'));
            $tag->addContent('Some text');
            $this->assertEqual($tag->getName(), 'a');
            $this->assertEqual($tag->getDefault(), 'Some text');
        }
        
        function testWrapping() {
            $tag = &new SimpleTextAreaTag(array('cols' => '10', 'wrap' => 'physical'));
            $tag->addContent("Lot's of text that should be wrapped");
            $this->assertEqual(
                    $tag->getDefault(),
                    "Lot's of\r\ntext that\r\nshould be\r\nwrapped");
            $tag->setValue("New long text\r\nwith two lines");
            $this->assertEqual(
                    $tag->getValue(),
                    "New long\r\ntext\r\nwith two\r\nlines");
        }
        
        function testWrappingRemovesLeadingcariageReturn() {
            $tag = &new SimpleTextAreaTag(array('cols' => '20', 'wrap' => 'physical'));
            $tag->addContent("\rStuff");
            $this->assertEqual($tag->getDefault(), 'Stuff');
            $tag->setValue("\nNew stuff\n");
            $this->assertEqual($tag->getValue(), "New stuff\r\n");
        }
        
        function testBreaksAreNewlineAndCarriageReturn() {
            $tag = &new SimpleTextAreaTag(array('cols' => '10'));
            $tag->addContent("Some\nText\rwith\r\nbreaks");
            $this->assertEqual($tag->getValue(), "Some\r\nText\r\nwith\r\nbreaks");
        }
    }
    
    class TestOfCheckbox extends UnitTestCase {
        
        function testCanSetCheckboxToNamedValueWithBooleanTrue() {
            $tag = &new SimpleCheckboxTag(array('name' => 'a', 'value' => 'A'));
            $this->assertEqual($tag->getValue(), false);
            $tag->setValue(true);
            $this->assertIdentical($tag->getValue(), 'A');
        }
    }
    
    class TestOfSelection extends UnitTestCase {
        
        function testEmpty() {
            $tag = &new SimpleSelectionTag(array('name' => 'a'));
            $this->assertIdentical($tag->getValue(), '');
        }
        
        function testSingle() {
            $tag = &new SimpleSelectionTag(array('name' => 'a'));
            $option = &new SimpleOptionTag(array());
            $option->addContent('AAA');
            $tag->addTag($option);
            $this->assertEqual($tag->getValue(), 'AAA');
        }
        
        function testSingleDefault() {
            $tag = &new SimpleSelectionTag(array('name' => 'a'));
            $option = &new SimpleOptionTag(array('selected' => ''));
            $option->addContent('AAA');
            $tag->addTag($option);
            $this->assertEqual($tag->getValue(), 'AAA');
        }
        
        function testSingleMappedDefault() {
            $tag = &new SimpleSelectionTag(array('name' => 'a'));
            $option = &new SimpleOptionTag(array('selected' => '', 'value' => 'aaa'));
            $option->addContent('AAA');
            $tag->addTag($option);
            $this->assertEqual($tag->getValue(), 'aaa');
        }
        
        function testStartsWithDefault() {
            $tag = &new SimpleSelectionTag(array('name' => 'a'));
            $a = &new SimpleOptionTag(array());
            $a->addContent('AAA');
            $tag->addTag($a);
            $b = &new SimpleOptionTag(array('selected' => ''));
            $b->addContent('BBB');
            $tag->addTag($b);
            $c = &new SimpleOptionTag(array());
            $c->addContent('CCC');
            $tag->addTag($c);
            $this->assertEqual($tag->getValue(), 'BBB');
        }
        
        function testSettingOption() {
            $tag = &new SimpleSelectionTag(array('name' => 'a'));
            $a = &new SimpleOptionTag(array());
            $a->addContent('AAA');
            $tag->addTag($a);
            $b = &new SimpleOptionTag(array('selected' => ''));
            $b->addContent('BBB');
            $tag->addTag($b);
            $c = &new SimpleOptionTag(array());
            $c->addContent('CCC');
            $tag->setValue('AAA');
            $this->assertEqual($tag->getValue(), 'AAA');
        }
        
        function testSettingMappedOption() {
            $tag = &new SimpleSelectionTag(array('name' => 'a'));
            $a = &new SimpleOptionTag(array('value' => 'aaa'));
            $a->addContent('AAA');
            $tag->addTag($a);
            $b = &new SimpleOptionTag(array('value' => 'bbb', 'selected' => ''));
            $b->addContent('BBB');
            $tag->addTag($b);
            $c = &new SimpleOptionTag(array('value' => 'ccc'));
            $c->addContent('CCC');
            $tag->addTag($c);
            $tag->setValue('AAA');
            $this->assertEqual($tag->getValue(), 'aaa');
            $tag->setValue('ccc');
            $this->assertEqual($tag->getValue(), 'ccc');
        }
        
        function testSelectionDespiteSpuriousWhitespace() {
            $tag = &new SimpleSelectionTag(array('name' => 'a'));
            $a = &new SimpleOptionTag(array());
            $a->addContent(' AAA ');
            $tag->addTag($a);
            $b = &new SimpleOptionTag(array('selected' => ''));
            $b->addContent(' BBB ');
            $tag->addTag($b);
            $c = &new SimpleOptionTag(array());
            $c->addContent(' CCC ');
            $tag->addTag($c);
            $this->assertEqual($tag->getValue(), ' BBB ');
            $tag->setValue('AAA');
            $this->assertEqual($tag->getValue(), ' AAA ');
        }
        
        function testFailToSetIllegalOption() {
            $tag = &new SimpleSelectionTag(array('name' => 'a'));
            $a = &new SimpleOptionTag(array());
            $a->addContent('AAA');
            $tag->addTag($a);
            $b = &new SimpleOptionTag(array('selected' => ''));
            $b->addContent('BBB');
            $tag->addTag($b);
            $c = &new SimpleOptionTag(array());
            $c->addContent('CCC');
            $tag->addTag($c);
            $this->assertFalse($tag->setValue('Not present'));
            $this->assertEqual($tag->getValue(), 'BBB');
        }
        
        function testNastyOptionValuesThatLookLikeFalse() {
            $tag = &new SimpleSelectionTag(array('name' => 'a'));
            $a = &new SimpleOptionTag(array('value' => '1'));
            $a->addContent('One');
            $tag->addTag($a);
            $b = &new SimpleOptionTag(array('value' => '0'));
            $b->addContent('Zero');
            $tag->addTag($b);
            $this->assertIdentical($tag->getValue(), '1');
            $tag->setValue('Zero');
            $this->assertIdentical($tag->getValue(), '0');
        }
        
        function testBlankOption() {
            $tag = &new SimpleSelectionTag(array('name' => 'A'));
            $a = &new SimpleOptionTag(array());
            $tag->addTag($a);
            $b = &new SimpleOptionTag(array());
            $b->addContent('b');
            $tag->addTag($b);
            $this->assertIdentical($tag->getValue(), '');
            $tag->setValue('b');
            $this->assertIdentical($tag->getValue(), 'b');
            $tag->setValue('');
            $this->assertIdentical($tag->getValue(), '');
        }
        
        function testMultipleDefaultWithNoSelections() {
            $tag = &new MultipleSelectionTag(array('name' => 'a', 'multiple' => ''));
            $a = &new SimpleOptionTag(array());
            $a->addContent('AAA');
            $tag->addTag($a);
            $b = &new SimpleOptionTag(array());
            $b->addContent('BBB');
            $tag->addTag($b);
            $this->assertIdentical($tag->getDefault(), array());
            $this->assertIdentical($tag->getValue(), array());
        }
        
        function testMultipleDefaultWithSelections() {
            $tag = &new MultipleSelectionTag(array('name' => 'a', 'multiple' => ''));
            $a = &new SimpleOptionTag(array('selected' => ''));
            $a->addContent('AAA');
            $tag->addTag($a);
            $b = &new SimpleOptionTag(array('selected' => ''));
            $b->addContent('BBB');
            $tag->addTag($b);
            $this->assertIdentical($tag->getDefault(), array('AAA', 'BBB'));
            $this->assertIdentical($tag->getValue(), array('AAA', 'BBB'));
        }
        
        function testSettingMultiple() {
            $tag = &new MultipleSelectionTag(array('name' => 'a', 'multiple' => ''));
            $a = &new SimpleOptionTag(array('selected' => ''));
            $a->addContent('AAA');
            $tag->addTag($a);
            $b = &new SimpleOptionTag(array());
            $b->addContent('BBB');
            $tag->addTag($b);
            $c = &new SimpleOptionTag(array('selected' => '', 'value' => 'ccc'));
            $c->addContent('CCC');
            $tag->addTag($c);
            $this->assertIdentical($tag->getDefault(), array('AAA', 'ccc'));
            $this->assertTrue($tag->setValue(array('BBB', 'ccc')));
            $this->assertIdentical($tag->getValue(), array('BBB', 'ccc'));
            $this->assertTrue($tag->setValue(array()));
            $this->assertIdentical($tag->getValue(), array());
        }
        
        function testFailToSetIllegalOptionsInMultiple() {
            $tag = &new MultipleSelectionTag(array('name' => 'a', 'multiple' => ''));
            $a = &new SimpleOptionTag(array('selected' => ''));
            $a->addContent('AAA');
            $tag->addTag($a);
            $b = &new SimpleOptionTag(array());
            $b->addContent('BBB');
            $tag->addTag($b);
            $this->assertFalse($tag->setValue(array('CCC')));
            $this->assertTrue($tag->setValue(array('AAA', 'BBB')));
            $this->assertFalse($tag->setValue(array('AAA', 'CCC')));
        }
    }
    
    class TestOfRadioGroup extends UnitTestCase {
        
        function testEmptyGroup() {
            $group = &new SimpleRadioGroup();
            $this->assertIdentical($group->getDefault(), false);
            $this->assertIdentical($group->getValue(), false);
            $this->assertFalse($group->setValue('a'));
        }
        
        function testReadingSingleButtonGroup() {
            $group = &new SimpleRadioGroup();
            $group->addWidget(new SimpleRadioButtonTag(
                    array('value' => 'A', 'checked' => '')));
            $this->assertIdentical($group->getDefault(), 'A');
            $this->assertIdentical($group->getValue(), 'A');
        }
        
        function testReadingMultipleButtonGroup() {
            $group = &new SimpleRadioGroup();
            $group->addWidget(new SimpleRadioButtonTag(
                    array('value' => 'A')));
            $group->addWidget(new SimpleRadioButtonTag(
                    array('value' => 'B', 'checked' => '')));
            $this->assertIdentical($group->getDefault(), 'B');
            $this->assertIdentical($group->getValue(), 'B');
        }
        
        function testFailToSetUnlistedValue() {
            $group = &new SimpleRadioGroup();
            $group->addWidget(new SimpleRadioButtonTag(array('value' => 'z')));
            $this->assertFalse($group->setValue('a'));
            $this->assertIdentical($group->getValue(), false);
        }
        
        function testSettingNewValueClearsTheOldOne() {
            $group = &new SimpleRadioGroup();
            $group->addWidget(new SimpleRadioButtonTag(
                    array('value' => 'A')));
            $group->addWidget(new SimpleRadioButtonTag(
                    array('value' => 'B', 'checked' => '')));
            $this->assertTrue($group->setValue('A'));
            $this->assertIdentical($group->getValue(), 'A');
        }
        
        function testIsIdMatchesAnyWidgetInSet() {
            $group = &new SimpleRadioGroup();
            $group->addWidget(new SimpleRadioButtonTag(
                    array('value' => 'A', 'id' => 'i1')));
            $group->addWidget(new SimpleRadioButtonTag(
                    array('value' => 'B', 'id' => 'i2')));
            $this->assertFalse($group->isId('i0'));
            $this->assertTrue($group->isId('i1'));
            $this->assertTrue($group->isId('i2'));
        }
        
        function testIsLabelMatchesAnyWidgetInSet() {
            $group = &new SimpleRadioGroup();
            $button1 = &new SimpleRadioButtonTag(array('value' => 'A'));
            $button1->setLabel('one');
            $group->addWidget($button1);
            $button2 = &new SimpleRadioButtonTag(array('value' => 'B'));
            $button2->setLabel('two');
            $group->addWidget($button2);
            $this->assertFalse($group->isLabel('three'));
            $this->assertTrue($group->isLabel('one'));
            $this->assertTrue($group->isLabel('two'));
        }
    }
    
    class TestOfTagGroup extends UnitTestCase {
        
        function testReadingMultipleCheckboxGroup() {
            $group = &new SimpleCheckboxGroup();
            $group->addWidget(new SimpleCheckboxTag(array('value' => 'A')));
            $group->addWidget(new SimpleCheckboxTag(
                    array('value' => 'B', 'checked' => '')));
            $this->assertIdentical($group->getDefault(), 'B');
            $this->assertIdentical($group->getValue(), 'B');
        }
        
        function testReadingMultipleUncheckedItems() {
            $group = &new SimpleCheckboxGroup();
            $group->addWidget(new SimpleCheckboxTag(array('value' => 'A')));
            $group->addWidget(new SimpleCheckboxTag(array('value' => 'B')));            
            $this->assertIdentical($group->getDefault(), false);
            $this->assertIdentical($group->getValue(), false);
        }
        
        function testReadingMultipleCheckedItems() {
            $group = &new SimpleCheckboxGroup();
            $group->addWidget(new SimpleCheckboxTag(
                    array('value' => 'A', 'checked' => '')));
            $group->addWidget(new SimpleCheckboxTag(
                    array('value' => 'B', 'checked' => '')));
            $this->assertIdentical($group->getDefault(), array('A', 'B'));
            $this->assertIdentical($group->getValue(), array('A', 'B'));
        }
        
        function testSettingSingleValue() {
            $group = &new SimpleCheckboxGroup();
            $group->addWidget(new SimpleCheckboxTag(array('value' => 'A')));
            $group->addWidget(new SimpleCheckboxTag(array('value' => 'B')));
            $this->assertTrue($group->setValue('A'));
            $this->assertIdentical($group->getValue(), 'A');
            $this->assertTrue($group->setValue('B'));
            $this->assertIdentical($group->getValue(), 'B');
        }
        
        function testSettingMultipleValues() {
            $group = &new SimpleCheckboxGroup();
            $group->addWidget(new SimpleCheckboxTag(array('value' => 'A')));
            $group->addWidget(new SimpleCheckboxTag(array('value' => 'B')));
            $this->assertTrue($group->setValue(array('A', 'B')));
            $this->assertIdentical($group->getValue(), array('A', 'B'));
        }
        
        function testSettingNoValue() {
            $group = &new SimpleCheckboxGroup();
            $group->addWidget(new SimpleCheckboxTag(array('value' => 'A')));
            $group->addWidget(new SimpleCheckboxTag(array('value' => 'B')));
            $this->assertTrue($group->setValue(false));
            $this->assertIdentical($group->getValue(), false);
        }
        
        function testIsIdMatchesAnyIdInSet() {
            $group = &new SimpleCheckboxGroup();
            $group->addWidget(new SimpleCheckboxTag(array('id' => 1, 'value' => 'A')));
            $group->addWidget(new SimpleCheckboxTag(array('id' => 2, 'value' => 'B')));
            $this->assertFalse($group->isId(0));
            $this->assertTrue($group->isId(1));
            $this->assertTrue($group->isId(2));
        }
    }
    
    class TestOfUploadWidget extends UnitTestCase {
        
        function testValueIsFilePath() {
            $upload = &new SimpleUploadTag(array('name' => 'a'));
            $upload->setValue(dirname(__FILE__) . '/support/upload_sample.txt');
            $this->assertEqual($upload->getValue(), dirname(__FILE__) . '/support/upload_sample.txt');
        }
        
        function testSubmitsFileContents() {
            $encoding = &new MockSimpleMultipartEncoding();
            $encoding->expectOnce('attach', array(
                    'a',
                    'Sample for testing file upload',
                    'upload_sample.txt'));
            $upload = &new SimpleUploadTag(array('name' => 'a'));
            $upload->setValue(dirname(__FILE__) . '/support/upload_sample.txt');
            $upload->write($encoding);
        }
    }
    
    class TestOfLabelTag extends UnitTestCase {
        
        function testLabelShouldHaveAnEndTag() {
            $label = &new SimpleLabelTag(array());
            $this->assertTrue($label->expectEndTag());
        }
        
        function testContentIsTextOnly() {
            $label = &new SimpleLabelTag(array());
            $label->addContent('Here <tag>are</tag> words');
            $this->assertEqual($label->getText(), 'Here are words');
        }
    }
?>